home *** CD-ROM | disk | FTP | other *** search
/ Aminet 15 / Aminet 15 - Nov 1996.iso / Aminet / dev / misc / libx11.lha / libX11 / images.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-09-22  |  41.5 KB  |  1,424 lines
  1. /* Copyright (c) 1996 by Terje Pedersen.  All Rights Reserved   */
  2. /*                                                              */
  3. /* By using this code you will agree to these terms:            */
  4. /*                                                              */
  5. /* 1. You may not use this code for profit in any way or form   */
  6. /*    unless an agreement with the author has been reached.     */
  7. /*                                                              */
  8. /* 2. The author is not responsible for any damages caused by   */
  9. /*    the use of this code.                                     */
  10. /*                                                              */
  11. /* 3. All modifications are to be released to the public.       */
  12. /*                                                              */
  13. /* Thats it! Have fun!                                          */
  14. /* TP                                                           */
  15. /*                                                              */
  16.  
  17. /***
  18.    NAME
  19.      images
  20.    PURPOSE
  21.      add Image handling to libX11
  22.    NOTES
  23.      
  24.    HISTORY
  25.      Terje Pedersen - Oct 27, 1994: Created.
  26. ***/
  27.  
  28. #include <intuition/intuition.h>
  29. #include <proto/intuition.h>
  30. #include <proto/graphics.h>
  31. #include <graphics/gfx.h>
  32. #include <graphics/gfxmacros.h>
  33.  
  34. #include <hardware/blit.h>
  35.  
  36. #include <proto/intuition.h>
  37.  
  38. #include <dos.h>
  39. #include <string.h>
  40. #include <stdlib.h>
  41. #include <stdio.h>
  42. #include <signal.h>
  43.  
  44. #include "libX11.h"
  45. #define XLIB_ILLEGAL_ACCESS 1
  46.  
  47. #include <X11/X.h>
  48. #include <X11/Xlib.h>
  49.  
  50. #include "amigax_proto.h"
  51. #include "amiga_x.h"
  52. #undef memset
  53.  
  54. /*******************************************************************************************/
  55. /* externals */
  56. /*******************************************************************************************/
  57.  
  58. extern struct Screen *Scr,*wb;
  59. extern struct RastPort temprp,*mainrp;
  60. extern struct RastPort backrp;
  61. extern GC      amiga_gc;
  62.  
  63. extern int X_relx,X_rely,X_right,X_bottom,X_width,X_height;
  64. extern struct RastPort *drp;
  65.  
  66. /*******************************************************************************************/
  67. long ANop(XImage *xim,int x,int y);
  68. __stdargs int ADestroyImage(struct _XImage *xim);
  69.  
  70. #ifdef DEBUG
  71. void showbitmap(struct BitMap *bm,int width,int height,int pos);
  72. #endif
  73.  
  74. int show=0;
  75.  
  76. extern WORD *Xcurrent_tile;
  77. int Xhas_tile=0,Xtile_size;
  78.  
  79. long ANop(XImage *xim,int x,int y){
  80. /*
  81.   printf("internal undefined func called!\nPress return..\n");
  82.   getchar();
  83. */
  84.   return(0);
  85. }
  86.  
  87. XImage *ANop2(){
  88. /*
  89.   printf("internal undefined func(2) called!\nnPress return..");
  90.   getchar();
  91. */
  92.   return((XImage*)NULL);
  93. }
  94.  
  95. __stdargs ADestroyImage(struct _XImage *xim)
  96. {
  97. #ifdef DEBUGXEMUL_ENTRY
  98.   printf("ADestroyImage\n");
  99. #endif
  100.   if(xim->data!=NULL) free(xim->data);
  101.   List_RemoveEntry(pMemoryList,(void*)xim);
  102.   xim=NULL;
  103.   return(1);
  104. }
  105.  
  106. unsigned long XGetPixel(struct _XImage *xim,int x,int y){
  107.   int bit;
  108.   if(xim->bitmap_bit_order==LSBFirst){
  109.     if(xim->depth==1){
  110.       int byte=*(xim->data+y*xim->bytes_per_line+(x>>3));
  111.       bit=byte&(1<<(x%8));
  112.     }
  113.     else{
  114.       int byte=*(xim->data+y*xim->bytes_per_line+x);
  115.       bit=byte;
  116.     }
  117.   }
  118.   else{
  119.     if(xim->depth==1){
  120.       int byte=*(xim->data+y*xim->bytes_per_line+(x>>3));
  121.       bit=byte&(128>>(x%8));
  122.     }
  123.     else{
  124.       int byte=*(xim->data+y*xim->bytes_per_line+x);
  125.       bit=byte;
  126.     }
  127.   }
  128.   return((unsigned long)bit);
  129. }
  130.  
  131. int XDestroyImage(ximage)
  132.      XImage *ximage;
  133. {
  134. #ifdef DEBUGXEMUL_ENTRY
  135.   printf("XDestroyImage\n");
  136. #endif
  137.   if(ximage->data!=0) free(ximage->data);
  138.   List_RemoveEntry(pMemoryList,(void*)ximage);
  139. }
  140.  
  141. extern __stdargs int XPut_Pixel(XImage *xim, int x, int y, unsigned long pixel);
  142. extern __stdargs unsigned long  XGet_pixel(struct _XImage*,int,int);
  143.  
  144. #include <X11/Xutil.h>
  145. #include <X11/Intrinsic.h>
  146. #include <X11/IntrinsicP.h>
  147.  
  148. #include <libraries/mui.h>
  149. #include <proto/muimaster.h>
  150.  
  151. XImage *XCreateImage(display, visual, depth, format, offset,
  152.              data, width, height, bitmap_pad, bytes_per_line)
  153.      Display *display;
  154.      Visual *visual;
  155.      unsigned int depth;
  156.      int format;
  157.      int offset;
  158.      char *data;
  159.      unsigned int width;
  160.      unsigned int height;
  161.      int bitmap_pad;
  162.      int bytes_per_line;
  163. {
  164.   XImage *xim;
  165. #ifdef DEBUGXEMUL_ENTRY
  166.   printf("XCreateImage (%d,%d) %d\n",width,height,depth);
  167. #endif
  168.   xim=(XImage*)malloc(sizeof(XImage));
  169.   if(!xim)  X11resource_exit(IMAGES1);
  170.   List_AddEntry(pMemoryList,(void*)xim);
  171.   xim->width=width;
  172.   xim->height=height;
  173.   xim->bitmap_pad=0 /*bitmap_pad*/;
  174.   xim->bitmap_unit=16;
  175.   xim->bytes_per_line=((width*depth)+7)>>3;
  176. /*
  177.   if(depth==3)
  178.     xim->bytes_per_line+=2;
  179. */
  180.   xim->byte_order=0 /*MSBFirst*/;
  181.   xim->depth=depth;
  182.   xim->format=format;
  183.   xim->xoffset=offset;
  184.   xim->data=data;
  185.   xim->f.create_image=ANop2;
  186.   xim->f.destroy_image=ADestroyImage;
  187.   xim->f.get_pixel=XGet_pixel;
  188.   xim->f.put_pixel=XPut_Pixel;
  189.   xim->f.sub_image=ANop;
  190.   xim->f.add_pixel=ANop;
  191.  
  192. /*
  193.   if(xim->data)
  194.     memset(xim->data,0,xim->height*xim->bytes_per_line);
  195. */
  196.  
  197.   switch(format){
  198.   case XYBitmap: xim->bits_per_pixel=1; break;
  199.   case XYPixmap: break;
  200.   case ZPixmap:
  201.     xim->bits_per_pixel=depth;
  202. /*
  203.     switch(xim->bitmap_pad){
  204.     case  8: xim->bits_per_pixel=8;break;
  205.     case 16: xim->bits_per_pixel=8;break;
  206.     case 32: xim->bits_per_pixel=8;break;
  207.     }*/
  208.     break;
  209.   }
  210.   return(xim);
  211. }
  212.  
  213. extern void __asm PlanarToChunkyAsm(register __a0 struct p2cStruct *);
  214. extern void __asm ChunkyToPlanarAsm(register __a0 struct c2pStruct *);
  215. extern struct BitMap *alloc_bitmap(int,int,int,int);
  216. extern int free_bitmap(struct BitMap *);
  217. /*extern struct Window *rootwin;*/
  218. extern int x_clip_origin,y_clip_origin,gfxcard;
  219.  
  220. #ifndef NO020
  221. struct p2cStruct{
  222.   struct BitMap *bmap;
  223.   UWORD startX, startY, width, height;
  224.   UBYTE *chunkybuffer;
  225. } p2c;
  226.  
  227. struct c2pStruct {
  228.   struct BitMap *bmap;
  229.   UWORD startX, startY, width, height;
  230.   UBYTE *chunkybuffer;
  231. } c2p;
  232.  
  233. #endif
  234.  
  235. XPutImage_nochunky(
  236.      Display *display,
  237.      Drawable d,
  238.      GC gc,
  239.      XImage *image,
  240.      int src_x, int src_y,
  241.      int dest_x, int dest_y,
  242.      unsigned int width, unsigned int height
  243. );
  244.  
  245. XPutImage_nochunky(display, d, gc, image, src_x, src_y,
  246.       dest_x, dest_y, width, height)
  247.      Display *display;
  248.      Drawable d;
  249.      GC gc;
  250.      XImage *image;
  251.      int src_x, src_y;
  252.      int dest_x, dest_y;
  253.      unsigned int width, height;
  254. {
  255.   UBYTE *data=NULL;
  256.   int bt,bl;
  257.   int bwide=(((image->width+15)>>4)<<4);
  258.   int fromx,fromy;
  259.   struct Window *destwin;
  260.   struct BitMap *destBM;
  261.   struct RastPort *mainrp;
  262.   int destdrawable=X11Drawables[d];
  263.  
  264. /*
  265.   char *pData;
  266.   if( image->depth<8 ){
  267.     pData=malloc(image->width*image->height+16);
  268.     if(!pData){
  269.       return NULL;
  270.     }
  271.     make_8bit(image,pData);
  272.   } else pData=image->data;
  273. */
  274.   XClearArea(display,d,dest_x,dest_y,width,height,0);
  275.  
  276.   if(backrp.BitMap->Depth!=image->depth){
  277.     if(backrp.BitMap) free_bitmap(backrp.BitMap);
  278.     backrp.BitMap=NULL;
  279.   }  
  280.   X11testback(width,height,image->depth);
  281.   if(destdrawable==X11WINDOW){
  282.     destwin=X11DrawablesWindows[X11DrawablesMap[d]];
  283.     if(!destwin) return 0;
  284.     mainrp=destwin->RPort;
  285.     destBM=destwin->RPort->BitMap;
  286.     destdrawable=X11WINDOW;
  287.     bt=destwin->BorderTop;
  288.     bl=destwin->BorderLeft;
  289.   } else if(destdrawable==X11SUBWINDOW){
  290.     int child=X11DrawablesSubWindows[X11DrawablesMap[d]];
  291.     destwin=Agetwin(d);
  292.     prevwin=-1;
  293.     if(!destwin) return 0;
  294.     destBM=destwin->RPort->BitMap;
  295.     mainrp=destwin->RPort;
  296.     XClearArea(display,d,dest_x,dest_y,width,height,0);
  297.     bl=X11DrawablesChildren[child].x+destwin->BorderLeft;
  298.     bt=X11DrawablesChildren[child].y+destwin->BorderTop;
  299.     destdrawable=X11WINDOW;
  300.   } else if(destdrawable==X11MUI){
  301.     Object *obj=X11DrawablesMUI[X11DrawablesMap[d]];
  302.     destBM=_window(obj)->RPort->BitMap;
  303.     destwin=_window(obj);
  304.     mainrp=destwin->RPort;
  305.     destdrawable=X11WINDOW;
  306.     bl=_mleft(obj);
  307.     bt=_mtop(obj);
  308.   } else destBM=X11DrawablesBitmaps[X11DrawablesMap[d]].pBitMap;
  309.  
  310.   if(image->width!=bwide){
  311.     int i;
  312.     data=(UBYTE*)malloc(bwide*(image->height+1));
  313.     if(!data)  X11resource_exit(IMAGES2);
  314.     for(i=0;i<image->height;i++){
  315.       memset((data+(i+1)*bwide-16),0,16);
  316.       memcpy((data+i*bwide),(image->data+i*image->width),image->width);
  317.     }
  318.     fromx=dest_x;fromy=dest_y;
  319.   }else{
  320.     int size=image->width*image->height;
  321.     data=malloc(size+image->width);
  322.     if(!data)  X11resource_exit(IMAGES3);
  323.     memcpy(data,image->data,size);
  324.     if(width<image->width) {fromx=dest_x-src_x; fromy=dest_y-src_y;}
  325.     else { fromx=dest_x;fromy=dest_y;}
  326.   }
  327.   if(temprp.BitMap) free_bitmap(temprp.BitMap);
  328.   temprp.BitMap=alloc_bitmap(image->width+16,1,image->depth,BMF_CLEAR);
  329.  
  330.   if(!CG.bNeedClip){
  331.     if(destdrawable==X11WINDOW)
  332.       WritePixelArray8(mainrp,bl+fromx,bt+fromy,bl+fromx+image->width-1,bt+fromy+image->height-1,data,&temprp);
  333.     else{
  334.       if(destBM->Depth!=1){
  335.     WritePixelArray8(&backrp,0,0,image->width-1,image->height-1,data,&temprp);
  336.     BltBitMap(backrp.BitMap,0,0,destBM,fromx,fromy,width,height,0xc0 /*(ABC|ABNC|ANBC)*/,0xFF,NULL);
  337.     WaitBlit();
  338.       } else{
  339.     int bdpl=(width+7)>>3,bpl=destBM->BytesPerRow,i;
  340.     for(i=0;i<bdpl*height;i++){
  341.       *(destBM->Planes[0]+(i%bdpl)+(int)(i/bdpl)*bpl)=*(image->data+i);
  342.     }
  343.       }
  344. /*      RectFill(&(wb->RastPort),20,20,20+width,20+height);
  345.       BltBitMapRastPort(backrp.BitMap,0,0,&(wb->RastPort),22,22,image->width,image->height,(ABC|ABNC|ANBC));*/
  346.     }
  347.   }else{
  348.     struct BitMap *bm=alloc_bitmap(width,height,image->depth,BMF_CLEAR);
  349.     WritePixelArray8(&backrp,0,0,image->width-1,image->height-1,data,&temprp);
  350.     BltBitMap(backrp.BitMap,0,0,bm,0,0,width,height,0xC0,0xFF,NULL);
  351.     WaitBlit();
  352.     if(destdrawable==X11WINDOW){
  353.       BltBitMap(destBM,dest_x+bl,dest_y+bt,backrp.BitMap,0,0,width,height,0xC0,0xFF,NULL);
  354.       WaitBlit();
  355.       BltMaskBitMapRastPort(bm,0,0,&backrp,0,0,width,height,0xc0 /*0xE0*/,CG.pClipBM->Planes[0]);
  356.       WaitBlit();
  357.       BltBitMap(backrp.BitMap,0,0,destBM,bl+dest_x,bt+dest_y,width,height,0xC0,0xFF,NULL);
  358.       WaitBlit();
  359.     }else{
  360.       int bm_srcx=0,bm_srcy=0;
  361.       int bm_width=width,bm_height=height;
  362.       int destWidth=GetBitMapAttr(destBM,BMA_WIDTH);
  363.       int destHeight=GetBitMapAttr(destBM,BMA_HEIGHT);
  364.       if(dest_x<0){bm_srcx=-dest_x; dest_x=0; bm_width-=bm_srcx;}
  365.       if(dest_y<0){bm_srcy=-dest_y; dest_y=0; bm_height-=bm_srcy;}
  366.       if(dest_x+width>destWidth){bm_width=bm_width-(dest_x+width-destWidth);}
  367.       if(dest_y+height>destHeight){bm_height=bm_height-(dest_y+height-destHeight);}
  368.       if(bm_width<1||bm_height<1){free_bitmap(bm); return(0);}
  369.  
  370.       BltBitMap(destBM,dest_x,dest_y,backrp.BitMap,0,0,width,height,0xC0,0xFF,NULL);
  371.       WaitBlit();
  372.       BltMaskBitMapRastPort(bm,bm_srcx,bm_srcy,&backrp,0,0,width,height,0xc0 /*0xE0*/,CG.pClipBM->Planes[0]);
  373.       WaitBlit();
  374.       BltBitMap(backrp.BitMap,0,0,destBM,dest_x,dest_y,bm_width,bm_height,0xC0,0xFF,NULL);
  375.       WaitBlit();
  376.     }
  377.     free_bitmap(bm);
  378.   }
  379.   free(data);
  380. }
  381.  
  382.  
  383. void X11testback(int width,int height,int depth)
  384. {
  385.   if(!backrp.BitMap){
  386.     InitRastPort(&backrp);
  387. /*    printf("has to set backrp! %d %d %d\n",width,height,wbdepth);*/
  388.     backrp.BitMap=alloc_bitmap(width,height,depth,BMF_CLEAR);
  389.     backrp.Layer=NULL;
  390.     DG.bNeedBackRP=1;
  391.   }else{
  392.     int destWidth;
  393.     int destHeight;
  394.     int destDepth;
  395.     if (DG.bUse30){
  396.       destWidth=GetBitMapAttr(backrp.BitMap,BMA_WIDTH);
  397.       destHeight=GetBitMapAttr(backrp.BitMap,BMA_HEIGHT);
  398.       destDepth=GetBitMapAttr(backrp.BitMap,BMA_DEPTH);
  399.     } else {
  400.       destWidth=backrp.BitMap->BytesPerRow*8;
  401.       destHeight=backrp.BitMap->Rows;
  402.       destDepth=backrp.BitMap->Depth;
  403.     }      
  404.     if(destWidth<width||destHeight<height||destDepth<depth){
  405.       free_bitmap(backrp.BitMap);
  406.       backrp.BitMap=alloc_bitmap(width,height,depth,BMF_CLEAR);
  407.     }
  408.   }
  409. }
  410.  
  411. make_8bit( XImage *image, char* pData, int src_x, int src_y, int width, int height ){
  412.   int p=0,x,y;
  413.  
  414.   switch (image->depth){
  415.   case 1:
  416.   case 8:
  417.     break;
  418.   case 2:
  419.     break;
  420.   case 3:
  421.     if(image->bytes_per_line==2){
  422.       for( y=0; y<src_y+height; y++ ){
  423.     p=y*(src_x+width);
  424.     pData[p++]=(image->data[y*image->bytes_per_line]&0xE0)>>5;
  425.     pData[p++]=(image->data[y*image->bytes_per_line+1]&0x1C)>>2;
  426.       }
  427.       return;
  428.     }
  429.     if(image->bytes_per_line==1){
  430.       for( y=0; y<src_y+height; y++ ){
  431.     p=y*(src_x+width);
  432.     pData[p]=(image->data[y*image->bytes_per_line]&0xE0)>>5;
  433.       }
  434.       return;
  435.     }
  436.     for( y=0; y<src_y+height-1; y++ ){
  437.       p=y*(src_x+width);
  438.       for( x=0; x<(int)((src_x+width)/3); x++ ){
  439.     pData[p++]=(image->data[y*image->bytes_per_line+x*3]&0xE0)>>5;
  440.     pData[p++]=(image->data[y*image->bytes_per_line+x*3]&0x1C)>>2;
  441.     pData[p++]=(image->data[y*image->bytes_per_line+x*3]&0x03)<<1|
  442.       (image->data[y*image->bytes_per_line+x*3+1]&0x80)>>7;
  443.     pData[p++]=(image->data[y*image->bytes_per_line+x*3+1]&0x70)>>4;
  444.     pData[p++]=(image->data[y*image->bytes_per_line+x*3+1]&0x0E)>>1;
  445.     pData[p++]=(image->data[y*image->bytes_per_line+x*3+1]&0x01)<<2|
  446.       (image->data[y*image->bytes_per_line+x*3+2]&0xC0)>>6;
  447.     pData[p++]=(image->data[y*image->bytes_per_line+x*3+2]&0x38)>>3;
  448.     pData[p++]=(image->data[y*image->bytes_per_line+x*3+2]&0x07);
  449.       }
  450.       /* and the rest */
  451.     }
  452.     p=((src_y+height)-1)*(src_x+width);
  453.     for( x=0; x<(int)((src_x+width)/3); x++ ){
  454.       pData[p++]=(image->data[y*image->bytes_per_line+x*3]&0xE0)>>5;
  455.       if(p==image->height*image->width) break;
  456.       pData[p++]=(image->data[y*image->bytes_per_line+x*3]&0x1C)>>2;
  457.       if(p==image->height*image->width) break;
  458.       pData[p++]=(image->data[y*image->bytes_per_line+x*3]&0x03)<<1|
  459.     (image->data[y*image->bytes_per_line+x*3+1]&0x80)>>7;
  460.       if(p==image->height*image->width) break;
  461.       pData[p++]=(image->data[y*image->bytes_per_line+x*3+1]&0x70)>>4;
  462.       if(p==image->height*image->width) break;
  463.       pData[p++]=(image->data[y*image->bytes_per_line+x*3+1]&0x0E)>>1;
  464.       if(p==image->height*image->width) break;
  465.       pData[p++]=(image->data[y*image->bytes_per_line+x*3+1]&0x01)<<2|
  466.     (image->data[y*image->bytes_per_line+x*3+2]&0xC0)>>6;
  467.       if(p==image->height*image->width) break;
  468.       pData[p++]=(image->data[y*image->bytes_per_line+x*3+2]&0x38)>>3;
  469.       if(p==image->height*image->width) break;
  470.       pData[p++]=(image->data[y*image->bytes_per_line+x*3+2]&0x07);
  471.     }
  472.  
  473.     break;
  474.   case 4:
  475.     for( y=0; y<src_y+height; y++ ){
  476.       p=y*(src_x+width);
  477.       for( x=0; x<src_x+width; x++ ){
  478.     pData[p++]=image->data[y*image->bytes_per_line+x]&0x0F;
  479.     pData[p++]=(image->data[y*image->bytes_per_line+x]&0xF0)>>4;
  480.       }
  481.     }
  482.     break;
  483.   }
  484. }
  485.  
  486. XPutImage(display, d, gc, image, src_x, src_y,
  487.       dest_x, dest_y, width, height)
  488.      Display *display;
  489.      Drawable d;
  490.      GC gc;
  491.      XImage *image;
  492.      int src_x, src_y;
  493.      int dest_x, dest_y;
  494.      unsigned int width, height;
  495. {
  496.   struct RastPort *mainrp=NULL;
  497.   struct Window *destwin;
  498.   struct BitMap *destBM;
  499.   int bt,bl;
  500.   int destdrawable=X11Drawables[d];
  501.   char *pData;
  502.  
  503. #ifdef DEBUGXEMUL_ENTRY
  504.   printf("XPutImage src [%d %d] dest [%d %d] size [%d %d]\n",src_x,src_y,
  505.      dest_x,dest_y,width,height);
  506. #endif
  507. #ifndef NO020
  508.  
  509.   if( image->depth<8 ){
  510.     pData=malloc((src_x+width)*(src_y+height)+16);
  511.     if(!pData) X11resource_exit(IMAGES11);
  512.     make_8bit(image,pData,src_x,src_y,width,height);
  513.   } else pData=image->data;
  514.   XClearArea(display,d,dest_x,dest_y,width,height,0);
  515.   if(gfxcard){
  516. #endif
  517.     XPutImage_nochunky(display,d,gc,image,src_x,src_y,dest_x,dest_y,width,height);
  518.     return;
  519. #ifndef NO020
  520.   }
  521.   if(destdrawable==X11WINDOW){
  522.     destwin=X11DrawablesWindows[X11DrawablesMap[d]];
  523.     if(!destwin) return 0;
  524.     destBM=destwin->RPort->BitMap;
  525.     mainrp=destwin->RPort;
  526. #if 0
  527.     SetRast(mainrp,0);
  528.     RefreshWindowFrame(destwin);
  529. #endif
  530.     bt=destwin->BorderTop;
  531.     bl=destwin->BorderLeft;
  532.   } else if(destdrawable==X11SUBWINDOW){
  533.     int child=X11DrawablesSubWindows[X11DrawablesMap[d]];
  534.     destwin=Agetwin(d);
  535.     prevwin=-1;
  536.     if(!destwin) return 0;
  537.     destBM=destwin->RPort->BitMap;
  538.     mainrp=destwin->RPort;
  539.     XClearArea(display,d,dest_x,dest_y,width,height,0);
  540.     bl=X11DrawablesChildren[child].x+destwin->BorderLeft+destwin->LeftEdge;
  541.     bt=X11DrawablesChildren[child].y+destwin->BorderTop+destwin->TopEdge;
  542.     destdrawable=X11WINDOW;
  543.   } else if(destdrawable==X11BITMAP){
  544.     destBM=X11DrawablesBitmaps[X11DrawablesMap[d]].pBitMap;
  545.   } else if(destdrawable==X11MUI){
  546.     Object *obj=X11DrawablesMUI[X11DrawablesMap[d]];
  547.     destBM=_window(obj)->RPort->BitMap;
  548.     destwin=_window(obj);
  549.     mainrp=destwin->RPort;
  550.     destdrawable=X11WINDOW;
  551.     bl=_mleft(obj);
  552.     bt=_mtop(obj);
  553.   }
  554.  
  555.   if(!CG.bNeedClip){
  556.     if(destdrawable==X11WINDOW){
  557.       if(image->depth!=1){
  558.     X11testback(image->width,image->height,image->depth);
  559.     c2p.bmap=backrp.BitMap;
  560.     c2p.startX = 0; c2p.startY = 0;
  561.     c2p.width = image->width; c2p.height = image->height;
  562.     c2p.chunkybuffer = pData;
  563.     ChunkyToPlanarAsm(&c2p);
  564.     BltBitMapRastPort(backrp.BitMap,src_x,src_y,destwin->RPort,dest_x+bl,dest_y+bt,width,height,
  565.               0xc0 /*(ABC|ABNC|ANBC)*/);
  566.     WaitBlit();
  567.       } else {
  568.     int y;
  569.     struct BitMap *bm=alloc_bitmap(image->width,image->height,1,0);
  570.     for( y=0; y<image->height; y++ )
  571.       memcpy(bm->Planes[0]+y*bm->BytesPerRow,image->data+y*image->bytes_per_line,image->bytes_per_line);
  572.     BltBitMapRastPort(bm,src_x,src_y,destwin->RPort,dest_x+bl,dest_y+bt,width,height,0xc0 /*(ABC|ABNC|ANBC)*/);
  573.     free_bitmap(bm);
  574.       }
  575.     }
  576.     else{
  577.       X11testback(image->width,image->height,image->depth);
  578.       if(destBM->Depth!=1){
  579.     c2p.bmap=backrp.BitMap;
  580.     c2p.startX = 0; c2p.startY = 0;
  581.     c2p.width = image->width; c2p.height = image->height;
  582.     c2p.chunkybuffer = pData;
  583.     ChunkyToPlanarAsm(&c2p);
  584.     BltBitMap(backrp.BitMap,src_x,src_y,destBM,dest_x,dest_y,width,height,0xc0 /*(ABC|ABNC|ANBC)*/,0xFF,NULL);
  585.     WaitBlit();
  586.       }else{
  587.     int bdpl=(width+7)>>3,bpl=destBM->BytesPerRow,i;
  588.     for(i=0;i<bdpl*height;i++){
  589.       *(destBM->Planes[0]+(i%bdpl)+(int)(i/bdpl)*bpl)=*(image->data+i);
  590.     }
  591.       }
  592.     }
  593.   }else{
  594.     struct BitMap *bm;
  595.     X11testback(image->width,image->height,image->depth);
  596.     bm=alloc_bitmap(image->width,image->height,image->depth,BMF_CLEAR);
  597.     c2p.bmap=bm;
  598.     c2p.startX=0; c2p.startY=0;
  599.     c2p.width=image->width; c2p.height=image->height;
  600.     c2p.chunkybuffer = pData;
  601.     ChunkyToPlanarAsm(&c2p);
  602.     if(X11Drawables[d]==X11WINDOW){
  603.       BltBitMap(destBM,bl+dest_x,bt+dest_y,backrp.BitMap,0,0,width,height,0xC0,0xFF,NULL);
  604.       WaitBlit();
  605.       BltMaskBitMapRastPort(bm,0,0,&backrp,0,0,width,height,0xc0 /*0xE0*/,CG.pClipBM->Planes[0]);
  606.       WaitBlit();
  607.       BltBitMap(backrp.BitMap,0,0,mainrp->BitMap,bl+dest_x,bt+dest_y,width,height,0xC0,0xFF,NULL);
  608.       WaitBlit();
  609.     }
  610.     else{
  611.       int bm_srcx=0,bm_srcy=0;
  612.       int bm_width=width,bm_height=height;
  613.       int destWidth=GetBitMapAttr(destBM,BMA_WIDTH);
  614.       int destHeight=GetBitMapAttr(destBM,BMA_HEIGHT);
  615.       if(dest_x<0){bm_srcx=-dest_x; dest_x=0; bm_width-=bm_srcx;}
  616.       if(dest_y<0){bm_srcy=-dest_y; dest_y=0; bm_height-=bm_srcy;}
  617.       if(dest_x+width>destWidth){bm_width=bm_width-(dest_x+width-destWidth);}
  618.       if(dest_y+height>destHeight){bm_height=bm_height-(dest_y+height-destHeight);}
  619.       if(bm_width<1||bm_height<1){free_bitmap(bm); return(0);}
  620.       BltBitMap(destBM,dest_x,dest_y,backrp.BitMap,0,0,width,height,0xC0,0xFF,NULL);
  621.       WaitBlit();
  622.       BltMaskBitMapRastPort(bm,bm_srcx,bm_srcy,&backrp,0,0,width,height,0xc0 /*0xE0*/,CG.pClipBM->Planes[0]);
  623.       WaitBlit();
  624.       BltBitMap(backrp.BitMap,0,0,destBM,dest_x,dest_y,bm_width,bm_height,0xC0,0xFF,NULL);
  625.       WaitBlit();
  626.     }
  627.     free_bitmap(bm);
  628.   }
  629.   if( image->depth<8 )
  630.     free(pData);
  631.   return(0);
  632. #endif
  633. }
  634.  
  635. XImage *XGetImage_nochunky(
  636.      Display *display,
  637.      Drawable drawable,
  638.      int x, int y,
  639.      unsigned int width, unsigned int height,
  640.      unsigned long plane_mask,
  641.      int format);
  642.  
  643. XImage *XGetImage_nochunky(display, drawable, x, y, width, height,
  644.           plane_mask, format)
  645.      Display *display;
  646.      Drawable drawable;
  647.      int x, y;
  648.      unsigned int width, height;
  649.      unsigned long plane_mask;
  650.      int format;
  651. {
  652.   XImage *xi;
  653. #ifdef DEBUGXEMUL_ENTRY
  654.   printf("XGetImage\n");
  655. #endif
  656.   ANop(NULL,0,0);
  657.   return(0);
  658. /*
  659.   if(format==XYPixmap){ /* one plane pixmap */
  660.     struct BitMap *bm=alloc_bitmap(width,height,1,BMF_CLEAR);
  661. /*    printf("hm xypixmap..\n");*/
  662.     xi=XCreateImage(display,NULL,1,XYPixmap,0,0,width,height,0,bm->BytesPerRow);
  663.     xi->data=malloc(width*height);
  664.     if(!xi->data)  X11resource_exit(IMAGES4);
  665.     if(drawable==rootwin) p2c.bmap = rootwin->RPort.BitMap;
  666.     else p2c.bmap=(struct BitMap*)drawable;
  667.     BltBitMap(p2c.bmap,x,y,bm,0,0,width,height,0xC0,(UBYTE)plane_mask,NULL);
  668.     WaitBlit();
  669.     p2c.bmap=bm;
  670.     p2c.startX = x; p2c.startY = y;
  671.     p2c.width = width; p2c.height = height;
  672.     p2c.chunkybuffer = xi->data;
  673.     PlanarToChunkyAsm(&p2c);
  674.     free_bitmap(bm);
  675.   }else{
  676.     struct BitMap *bm=(struct BitMap *)drawable;
  677.     int depth=bm->Depth,i;
  678.     UBYTE *Line=malloc(((width+16)>>4)<<4);
  679.     if(!Line) X11resource_exit(IMAGES5);
  680.     X11testback(width,height,depth);
  681.     WaitTOF();
  682.     BltBitMapRastPort(bm,x,y,&backrp,0,0,width,height,0xC0);
  683.     WaitBlit();
  684.     free_bitmap(temprp.BitMap);
  685.     temprp.BitMap=alloc_bitmap(width+16,1,8,BMF_CLEAR);
  686.     xi=XCreateImage(display,NULL,depth,ZPixmap,0,0,width,height,8,0);
  687.     xi->data=malloc(width*height+16);
  688.     if(!xi->data)  X11resource_exit(IMAGES6);
  689.     for(i=0;i<height;i++){
  690.       ReadPixelLine8(&backrp,(unsigned long)0,(unsigned long)i,(unsigned long)width,(UBYTE*)Line,&temprp);
  691.       memcpy((UBYTE*)(xi->data+i*width),Line,width);
  692.     }
  693.     free(Line);
  694.   }
  695.   return(xi);
  696. */
  697. }
  698.  
  699. XImage *XGetImage(display, drawable, src_x, src_y, width, height,
  700.           plane_mask, format)
  701.      Display *display;
  702.      Drawable drawable;
  703.      int src_x, src_y;
  704.      unsigned int width, height;
  705.      unsigned long plane_mask;
  706.      int format;
  707. {
  708.   XImage *xi;
  709.   struct Window *destwin;
  710.   struct BitMap *destBM;
  711.   int x,y;
  712.  
  713. #ifdef DEBUGXEMUL_ENTRY
  714.   printf("XGetImage\n");
  715. #endif
  716. #ifndef NO020
  717.   if(drawable!=prevwin) if(!(drp=setup_win(drawable))) return NULL;
  718.  
  719.   src_x+=X_relx;
  720.   src_y+=X_rely;
  721.   if(X11Drawables[drawable]==X11WINDOW){
  722.     destwin=X11DrawablesWindows[X11DrawablesMap[drawable]];
  723.     if(!destwin) return 0;
  724.     destBM=destwin->RPort->BitMap;
  725.     src_x+=destwin->LeftEdge;
  726.     src_y+=destwin->TopEdge;
  727.   }else if(X11Drawables[drawable]==X11BITMAP){
  728.     destBM=X11DrawablesBitmaps[X11DrawablesMap[drawable]].pBitMap;
  729.   }else if(X11Drawables[drawable]==X11MUI){
  730.     Object *obj=X11DrawablesMUI[X11DrawablesMap[drawable]];
  731.     destBM=_window(obj)->RPort->BitMap;
  732.     destwin=_window(obj);
  733.   }
  734.   if(format==XYPixmap){ /* one plane pixmap */
  735.     struct BitMap *bm=alloc_bitmap(width,height,1,BMF_CLEAR);
  736.     xi=XCreateImage(display,NULL,1,XYPixmap,0,0,width,height,0,bm->BytesPerRow);
  737.     xi->data=malloc(bm->BytesPerRow*bm->Rows);
  738.     if(!xi->data)  X11resource_exit(IMAGES7);
  739.     xi->bitmap_bit_order=MSBFirst;
  740.     BltBitMap(destBM,src_x,src_y,bm,0,0,width,height,0xC0,(UBYTE)plane_mask,NULL);
  741.     WaitBlit();
  742.     xi->bytes_per_line=bm->BytesPerRow;
  743.     memcpy(xi->data,bm->Planes[0],bm->BytesPerRow*bm->Rows);
  744.     free_bitmap(bm);
  745.   }else{
  746.     int depth=destBM->Depth,i;
  747.     char *data2;
  748.     X11testback(width,height,depth);
  749.     if(backrp.BitMap) free_bitmap(backrp.BitMap);
  750.     backrp.BitMap=destBM;
  751. /*
  752.     BltBitMapRastPort(destBM,src_x,src_y,&backrp,0,0,width,height,0xC0);
  753.     WaitBlit();
  754. */
  755.     p2c.bmap=backrp.BitMap;
  756.     depth=p2c.bmap->Depth;
  757.     xi=XCreateImage(display,NULL,depth,ZPixmap,0,0,width,height,0,destBM->BytesPerRow);
  758.     data2=malloc(width*height+16);
  759.     xi->data=calloc(height*xi->bytes_per_line+16,1);
  760.     if(!data2||!xi->data)  X11resource_exit(IMAGES8);
  761.     p2c.startX = src_x; p2c.startY = src_y;
  762.     p2c.width = width; p2c.height = height;
  763.     p2c.chunkybuffer = data2;
  764.     PlanarToChunkyAsm(&p2c);
  765.     for( y=0; y<height; y++ )
  766.       for( x=0; x<width; x++ )
  767.     XPut_Pixel(xi,x,y,/*ReadPixel(&backrp,src_x+x,src_y+y)*/ data2[y*width+x]);
  768.     if(show) XPutImage(NULL,1,NULL,xi,0,0,0,0,width,height);
  769.     backrp.BitMap=NULL;
  770.     free(data2);
  771.   }
  772.   return(xi);
  773. #else
  774.   return 0;
  775. #endif
  776. }
  777.  
  778. XImage *XGetSubImage(display, drawable, x, y, width, height,
  779.              plane_mask, format, dest_image, dest_x, dest_y)
  780.      Display *display;
  781.      Drawable drawable;
  782.      int x, y;
  783.      unsigned int width, height;
  784.      unsigned long plane_mask;
  785.      int format;
  786.      XImage *dest_image;
  787.      int dest_x, dest_y;
  788. {
  789.   int bdpl,i;
  790.   struct Window *destwin;
  791.   struct BitMap *destBM;
  792. #ifdef DEBUGXEMUL
  793.   printf("XGetSubImage %d %d <%d,%d>\n",x,y,width,height);
  794. #endif
  795. #ifndef NO020
  796.  
  797.   if(X11Drawables[drawable]==X11WINDOW){
  798.     destwin=X11DrawablesWindows[X11DrawablesMap[drawable]];
  799.     if(!destwin) return 0;
  800.     destBM=destwin->RPort->BitMap;
  801.   }else if(X11Drawables[drawable]==X11BITMAP){
  802.     destBM=X11DrawablesBitmaps[X11DrawablesMap[drawable]].pBitMap;
  803.   }
  804.   if(X11Drawables[drawable]==X11WINDOW){
  805.   }else{
  806.     bdpl=(width+7)>>3;
  807.     for(i=0;i<bdpl*height;i++){
  808.       *(dest_image->data+i)=*(destBM->Planes[0]+(i%bdpl)+(int)(i/bdpl)*destBM->BytesPerRow);
  809.     }
  810.     return(dest_image);
  811.   }
  812. #endif
  813.   return(0);
  814. }
  815.  
  816. UBYTE X11invert(UBYTE n){
  817.   return((UBYTE)(((n&128)>>7)+((n&64)>>5)+((n&32)>>3)+((n&16)>>1)+((n&8)<<1)+((n&4)<<3)+((n&2)<<5)+((n&1)<<7)));
  818. }
  819.  
  820. Pixmap XCreateBitmapFromData(display, drawable, data,
  821.                  width, height)
  822.      Display *display;
  823.      Drawable drawable;
  824.      char *data;
  825.      unsigned int width, height;
  826. {/*   File 'xmgr.o'*/
  827.   Pixmap pm;
  828.   int bytes,i,bpl,bdpl;
  829.   struct BitMap *bm;
  830. #ifdef DEBUGXEMUL_ENTRY
  831.   printf("XCreateBitmapFromData (%d,%d)\n",width,height);
  832. #endif
  833.   pm=XCreatePixmap(display,drawable,width,height,1);
  834.   bm=X11DrawablesBitmaps[X11DrawablesMap[pm]].pBitMap;
  835.   bdpl=(width+7)>>3;
  836.   bytes=bdpl*height;
  837.   bpl=((width+15)>>4)<<1;
  838.   for(i=0;i<bytes;i++){
  839.     *(bm->Planes[0]+(i%bdpl)+(int)(i/bdpl)*bpl)=(byte)X11invert(data[i]);
  840.   }
  841. #ifdef DEBUG
  842.   if(show) showbitmap(bm,width,height,0);
  843. #endif
  844.   return(pm);
  845. }
  846.  
  847. XCopyArea(display, src, dest, gc, src_x, src_y, width,
  848.       height,  dest_x, dest_y)
  849.      Display *display;
  850.      Drawable src, dest;
  851.      GC gc;
  852.      int src_x, src_y;
  853.      unsigned int width, height;
  854.      int dest_x, dest_y;
  855. {
  856.   struct BitMap *from; /*=(struct BitMap*)src;*/
  857.   struct BitMap *to; /*=(struct BitMap*)dest;*/
  858.   struct Window *fromwindow;
  859.   struct Window *towindow;
  860.   extern struct RastPort drawrp;
  861.   int blitop=0xc0 /*(ABC|ABNC|ANBC)*/;
  862.   int srcdrawable=X11Drawables[src],destdrawable=X11Drawables[dest];
  863. #ifdef DEBUGXEMUL_ENTRY
  864.   printf("XCopyArea src %d %d dest %d %d size %dx%d\n",src_x,src_y,dest_x,dest_y,width,height);
  865. #endif
  866.  
  867.   if(!gc) gc=amiga_gc;
  868. /*
  869.   if(gc->values.function==GXxor){
  870.     blitop=0x3c;
  871.   }*/
  872.  
  873.   switch(srcdrawable){
  874.   case X11WINDOW:
  875.   case X11SUBWINDOW: {
  876.     struct Window *w=Agetwin(src);
  877.     prevwin=-1;
  878.     if(!w) return 0; /*srcdrawable=X11BITMAP;*/
  879.     from=w->RPort->BitMap;
  880.     fromwindow=w;
  881.     srcdrawable=X11WINDOW;
  882.     src_x=src_x+X_relx;
  883.     src_y=src_y+X_rely; 
  884.   } 
  885.     break;
  886.   case X11BITMAP:
  887.     from=X11DrawablesBitmaps[X11DrawablesMap[src]].pBitMap;
  888.     break;
  889.   case X11MUI: {
  890.     Object *obj=X11DrawablesMUI[X11DrawablesMap[src]];
  891.     from=_window(obj)->RPort->BitMap;
  892.     src_x=src_x+_mleft(obj);
  893.     src_y=src_y+_mtop(obj);
  894.   }
  895.     break;
  896.   }
  897.   switch(destdrawable){
  898.   case X11WINDOW:
  899.   case X11SUBWINDOW: {
  900.     struct Window *w=Agetwin(dest);
  901.     prevwin=-1;
  902.     if(!w) return 0; /* destdrawable=X11BITMAP; */
  903.     to=w->RPort->BitMap;
  904.     destdrawable=X11WINDOW;
  905.     towindow=w;
  906.     dest_x=dest_x+X_relx;
  907.     dest_y=dest_y+X_rely;
  908.   }
  909.     break;
  910.   case X11BITMAP:
  911.     to=X11DrawablesBitmaps[X11DrawablesMap[dest]].pBitMap;
  912.     X_relx=0;
  913.     X_rely=0;
  914.     X_width=X11DrawablesBitmaps[X11DrawablesMap[dest]].width;
  915.     X_height=X11DrawablesBitmaps[X11DrawablesMap[dest]].height;
  916.     break;
  917.   case X11MUI: {
  918.     Object *obj=X11DrawablesMUI[X11DrawablesMap[dest]];
  919.     to=_window(obj)->RPort->BitMap;
  920.     towindow=_window(obj);
  921.     destdrawable=X11WINDOW;
  922.     dest_x=dest_x+_mleft(obj);
  923.     dest_y=dest_y+_mtop(obj);
  924.     X_relx=_left(obj);
  925.     X_rely=_top(obj);
  926.     X_width=_mwidth(obj);
  927.     X_height=_mheight(obj);
  928.   }
  929.     break;
  930.   }
  931.  
  932.   if( dest_x+width>X_width+X_relx){
  933.     width=X_width+X_relx-dest_x;
  934.   }
  935.   if( dest_y+height>X_height+X_rely){
  936.     height=X_height+X_rely-dest_y;
  937.   }
  938.   if( dest_y<X_rely ) {
  939.     height-=X_rely-dest_y; dest_y=X_rely; src_y+=X_rely;
  940.   }
  941.   if( dest_x<X_relx ) {
  942.     width-=X_relx-dest_x; dest_x=X_relx; src_x+=X_relx; 
  943.   }
  944.   if(from->Depth!=to->Depth && gc->values.background!=0){
  945. /*
  946.     int oldbg=X11DrawablesBackground[dest];
  947. */
  948.     X11testback(width,height,to->Depth);
  949.     SetRast(&backrp,gc->values.background);
  950.     
  951. /*
  952.     X11DrawablesBackground[dest]=gc->values.background;
  953.     XClearArea(display,dest,dest_x-X_relx,dest_y-X_rely,width,height,0);
  954.     X11DrawablesBackground[dest]=oldbg;
  955. */
  956.  
  957.   }
  958.  
  959.   if(destdrawable==X11WINDOW){
  960.     if(from->Depth!=to->Depth && gc->values.background!=0){
  961.       SetAPen(&backrp,gc->values.foreground);
  962.       SetBPen(&backrp,gc->values.background);
  963.       if(gc->values.function==GXxor) SetDrMd(&backrp,COMPLEMENT);
  964.       else SetDrMd(&backrp,JAM1);
  965.     } else {
  966.       SetAPen(towindow->RPort,gc->values.foreground);
  967.       SetBPen(towindow->RPort,gc->values.background);
  968.       if(gc->values.function==GXxor) SetDrMd(towindow->RPort,COMPLEMENT);
  969.       else SetDrMd(towindow->RPort,JAM1);
  970.       prevgc=(GC)-1;
  971.     }
  972.   } else if(destdrawable==X11BITMAP){
  973.     drawrp.BitMap=(struct BitMap *)to;
  974.     SetAPen(&drawrp,gc->values.foreground);
  975.     SetBPen(&drawrp,gc->values.background);
  976.     if(gc->values.function==GXxor) SetDrMd(&drawrp,COMPLEMENT);
  977.     else SetDrMd(&drawrp,JAM1);
  978.     prevgc=(GC)-1;
  979.   }
  980.  
  981. #ifdef DEBUGXEMUL
  982.   printf("from bitmap (%dx%d) %d\n",from->BytesPerRow*8,from->Rows,from->Depth);
  983.   printf("to bitmap (%dx%d) %d\n",to->BytesPerRow*8,to->Rows,to->Depth);
  984. #endif
  985.   if(srcdrawable!=X11WINDOW&&destdrawable!=X11WINDOW){
  986.     if(!CG.bNeedClip){
  987.       int bt=dest_y,bl=dest_x;
  988.       WaitBlit();
  989.       if(from->Depth==1 && gc->values.background!=0){
  990.     if(gc->values.function!=GXxor){
  991.       BltPattern(&backrp,from->Planes[0],0,0,width-1,height-1,from->BytesPerRow);
  992.     } else 
  993.       {
  994.         BltTemplate(from->Planes[0],0,from->BytesPerRow,&backrp,0,0,width,height);
  995.       }
  996.     WaitBlit();
  997.     BltBitMapRastPort(backrp.BitMap,0,0,towindow->RPort,bl,bt,width,height,0xc0);
  998.       } else 
  999.     {
  1000.       BltBitMap(from,src_x,src_y,to,dest_x,dest_y,width,height,/*blitop*/ 0xc0,0xFF,NULL);
  1001.     }
  1002.     }
  1003.     else{
  1004.       int bt=dest_y,bl=dest_x;
  1005.       WaitBlit();
  1006.       if(from->Depth==1 && gc->values.background!=0){
  1007.     if(gc->values.function!=GXxor){
  1008.       BltPattern(&backrp,CG.pClipBM->Planes[0],0,0,width-1,height-1,
  1009.              CG.pClipBM->BytesPerRow);
  1010.     } else 
  1011.       {
  1012.         BltTemplate(from->Planes[0],0,from->BytesPerRow,&backrp,0,0,width,height);
  1013.       }
  1014.     WaitBlit();
  1015.     BltBitMapRastPort(backrp.BitMap,0,0,towindow->RPort,bl,bt,width,height,0xc0);
  1016.       } 
  1017.       else
  1018.     BltMaskBitMapRastPort(from,src_x,src_y,&drawrp,dest_x,dest_y,width,height,blitop,
  1019.                   CG.pClipBM->Planes[0]);
  1020.     }
  1021.   }else if(srcdrawable!=X11WINDOW&&destdrawable==X11WINDOW) {
  1022.     int bt=dest_y,bl=dest_x;
  1023.     WaitBlit();
  1024.     if(!CG.bNeedClip){
  1025.       if(from->Depth==1 && gc->values.background!=0){
  1026.     if(gc->values.function!=GXxor){
  1027.       BltPattern(&backrp,from->Planes[0],0,0,width-1,height-1,
  1028.              from->BytesPerRow);
  1029.     }else 
  1030.       {
  1031.         BltTemplate(from->Planes[0],0,from->BytesPerRow,&backrp,0,0,width,height);
  1032.       }
  1033.     WaitBlit();
  1034.     BltBitMapRastPort(backrp.BitMap,0,0,towindow->RPort,bl,bt,width,height,0xc0);
  1035.       } else 
  1036.     {
  1037.       BltBitMapRastPort(from,src_x,src_y,towindow->RPort,bl,bt,width,height,0xc0);
  1038.     }
  1039.     }
  1040.     else{
  1041.       if(gc->values.function!=GXxor){
  1042.     WaitBlit();
  1043.     BltPattern(towindow->RPort,CG.pClipBM->Planes[0],bl,bt,bl+width-1,bt+height-1,
  1044.            CG.pClipBM->BytesPerRow);
  1045.       }
  1046.       WaitBlit();
  1047.       BltTemplate(from->Planes[0],0,from->BytesPerRow,towindow->RPort,bl,bt,width,height);
  1048.       /*      BltMaskBitMapRastPort(from,src_x,src_y,towindow->RPort,bl,bt,width,height,blitop,
  1049.                 CG.pClipBM->Planes[0]);*/
  1050.     }
  1051.   }else if(srcdrawable==X11WINDOW&&destdrawable!=X11WINDOW){
  1052.     int bt=fromwindow->BorderTop /*+fromwindow->TopEdge*/,
  1053.     bl=fromwindow->BorderLeft /*+fromwindow->LeftEdge*/;
  1054.     WaitBlit();
  1055.     BltBitMap(fromwindow->RPort->BitMap,src_x+bl,src_y+bt,to,dest_x,dest_y,width,height,0xC0,
  1056.           0xFF,NULL);
  1057.   }else if(X11Drawables[src]==X11WINDOW&&X11Drawables[dest]==X11WINDOW){
  1058.     WaitBlit();
  1059.     BltBitMapRastPort(from,src_x+fromwindow->LeftEdge,src_y+fromwindow->TopEdge,towindow->RPort,dest_x,dest_y,width,height,0xc0);
  1060.   }
  1061.   return(0);
  1062. }
  1063.  
  1064. XCopyPlane(display, src, dest, gc, src_x, src_y, width,
  1065.        height, dest_x, dest_y, plane)
  1066.      Display *display;
  1067.      Drawable src, dest;
  1068.      GC gc;
  1069.      int src_x, src_y;
  1070.      unsigned int width, height;
  1071.      int dest_x, dest_y;
  1072.      unsigned long plane;
  1073. {
  1074.   struct BitMap *from;
  1075.   PLANEPTR oldplanes[8];
  1076.   int olddepth;
  1077. #ifdef DEBUGXEMUL_ENTRY
  1078.   printf("XCopyPlane\n");
  1079. #endif
  1080.   switch(X11Drawables[src]){
  1081.   case X11WINDOW:
  1082.   case X11SUBWINDOW: {
  1083.     struct Window *w=Agetwin(src);
  1084.     prevwin=-1;
  1085.     from=/*w->RPort*/ drp->BitMap;
  1086.     if(!w) return 0;
  1087.  
  1088.     src_x=src_x+X_relx;
  1089.     src_y=src_y+X_rely; 
  1090.   } 
  1091.     break;
  1092.   case X11BITMAP: {
  1093.     from=X11DrawablesBitmaps[X11DrawablesMap[src]].pBitMap;
  1094.   } 
  1095.     break;
  1096.   }
  1097.  
  1098.   if(plane){
  1099.     int i;
  1100.     for(i=0;i<8;i++){
  1101.       oldplanes[i]=from->Planes[i];
  1102.       from->Planes[i]=0;
  1103.     }
  1104.     from->Planes[0]=oldplanes[plane-1];
  1105.     olddepth=from->Depth;
  1106.     from->Depth=1;
  1107. /*
  1108.     if(dest==rootwin){
  1109.       SetWriteMask(rootwin->RPort,plane);
  1110.       SetAPen(rootwin->RPort,0);
  1111.       RectFill(rootwin->RPort,dest_x,dest_y,dest_x+width,dest_y+height);
  1112.       SetWriteMask(rootwin->RPort,255);
  1113.       prevgc=(GC)-1;
  1114.     }else{
  1115.       if(((int)dest>0&&(int)dest<CHILDRENAVAIL)){
  1116.     int x,y;
  1117.     Window w=Agetwin(dest);
  1118.     prevwin=-1;
  1119.     if(!w) return 0;
  1120.     x=dest_x;
  1121.     y=dest_y;
  1122.  
  1123.     SetAPen(/*w->RPort*/ drp,0);
  1124.     RectFill(/*w->RPort*/ drp,x,y,x+width,y+height);
  1125.     prevgc=NULL;
  1126.     prevwin=-1;
  1127.       }else{
  1128.     struct BitMap *to=(struct BitMap*)dest;
  1129.     memset(to->Planes[0],0,to->BytesPerRow*to->Rows);
  1130.       }
  1131.    }
  1132.  */
  1133.   }
  1134.   XCopyArea(display,src,dest,gc,src_x,src_y,width,height,dest_x,dest_y);
  1135.   if(plane){
  1136.     int i;
  1137.     for(i=0;i<8;i++)
  1138.       from->Planes[i]=oldplanes[i];
  1139.     from->Depth=olddepth;
  1140.   }
  1141.   return(0);
  1142. }
  1143.  
  1144.  
  1145. Pixmap X11prevtile=NULL;
  1146. int X11CurrentTile=0;
  1147. int X11PrevTile=0;
  1148.  
  1149. void X11Setup_Tile(GC gc, int tile){
  1150.   int i,j;
  1151.   int FillOp=gc->values.fill_style &0xff00;
  1152.   if( X11PrevTile==tile ) return;
  1153.   X11PrevTile=tile;
  1154.   if(tile && FillOp==NORMAL_FILL){
  1155.     int width,height;
  1156.     struct BitMap *bm=X11DrawablesBitmaps[X11DrawablesMap[tile]].pBitMap;
  1157.  
  1158.     if(Xcurrent_tile!=NULL){
  1159.       List_RemoveEntry(pMemoryList,(void*)Xcurrent_tile);
  1160.       Xcurrent_tile=NULL;
  1161.     }
  1162.     width=X11DrawablesBitmaps[X11DrawablesMap[tile]].width;
  1163.     height=X11DrawablesBitmaps[X11DrawablesMap[tile]].height;
  1164.     if(width>16){
  1165.       width=16;
  1166.       if(height>16) height=16;
  1167.     } else if(width<8) width=8;
  1168.  
  1169.     Xcurrent_tile=(WORD *) malloc((width>>3)*height);
  1170.     if(!Xcurrent_tile)  X11resource_exit(IMAGES10);
  1171.     List_AddEntry(pMemoryList,(void*)Xcurrent_tile);
  1172.     /*AllocMem(bm->BytesPerRow*bm->Rows,MEMF_CHIP);*/
  1173.     for(j=0;j<height;j++)
  1174.       for(i=0;i<(width>>3);i++)
  1175.     *((byte*)Xcurrent_tile+i+j*(width>>3))=(byte)*(bm->Planes[0]+i+j*bm->BytesPerRow);
  1176.     Xhas_tile=1;
  1177.     {
  1178.       double d=log(height)/log(2);
  1179.       Xtile_size=(int)ceil(d);
  1180.     }
  1181.     X11prevtile=tile;
  1182.   }
  1183. }
  1184.  
  1185. XSetTile(display, gc, tile)
  1186.      Display *display;
  1187.      GC gc;
  1188.      Pixmap tile;
  1189. {/*                File 'xvlib.o'*/
  1190. #ifdef DEBUGXEMUL_ENTRY
  1191.   printf("XSetTile\n");
  1192. #endif
  1193.   if(X11prevtile==tile) return;
  1194.   Xhas_tile=0;
  1195.   if(gc->values.tile!=tile && gc->values.tile!=0){
  1196.     XFreePixmap(NULL,gc->values.tile);
  1197.   }
  1198.   X11DrawablesBitmaps[X11DrawablesMap[tile]].bTileStipple=1;
  1199.   gc->values.tile=tile;
  1200.   prevgc=(GC)-1;
  1201.   return(0);
  1202. }
  1203.  
  1204. XSetStipple(display, gc, stipple)
  1205.      Display *display;
  1206.      GC gc;
  1207.      Pixmap stipple;
  1208. {
  1209. #ifdef DEBUGXEMUL_ENTRY
  1210.   printf("XSetStipple\n");
  1211. #endif
  1212.   if(gc->values.tile!=stipple && gc->values.tile!=0){
  1213.     XFreePixmap(NULL,gc->values.tile);
  1214.   }
  1215.   gc->values.tile=stipple;
  1216.   X11DrawablesBitmaps[X11DrawablesMap[stipple]].bTileStipple=1;
  1217.   if (X11DrawablesBitmaps[X11DrawablesMap[stipple]].width>16){
  1218.     gc->values.fill_style=INTERNAL_FILL|gc->values.fill_style;
  1219.   } else
  1220.     gc->values.fill_style=NORMAL_FILL|gc->values.fill_style;
  1221.   prevgc=(GC)-1;
  1222.   return(0);
  1223. }
  1224.  
  1225. Pixmap XCreatePixmapFromBitmapData(display, drawable, data,
  1226.                    width, height, fg, bg, depth)
  1227.      Display *display;
  1228.      Drawable drawable;
  1229.      char *data;
  1230.      unsigned int width, height;
  1231.      unsigned long fg, bg;
  1232.      unsigned int depth;
  1233. {
  1234.   Pixmap pm;
  1235. #if 0
  1236.   Pixmap pm2;
  1237.   struct BitMap *bm;
  1238.   struct BitMap *bitmap;
  1239.   int x,y,bpl;
  1240. #endif
  1241. #ifdef DEBUGXEMUL_ENTRY
  1242.   printf("XCreatePixmapFromBitmapData [%d,%d,%d]\n",width,height,depth);
  1243. #endif
  1244. #if 0
  1245.   pm=XCreatePixmap(display,drawable,width,height,depth);
  1246.   bm=X11DrawablesBitmaps[X11DrawablesMap[pm]].pBitMap;
  1247.   pm2=XCreateBitmapFromData(display,drawable,data,width,height);
  1248.   bitmap=X11DrawablesBitmaps[X11DrawablesMap[pm2]].pBitMap;
  1249. /*
  1250.   bitmap=alloc_bitmap(width,height,1,BMF_CLEAR);
  1251.  
  1252.   bpl=(width+7)>>3;
  1253.   for( y=0; y<height; y++ )
  1254.     for( x=0; x<bpl; x++ )
  1255.       *(bitmap->Planes[0]+y*bitmap->BytesPerRow+x)=X11invert(*(data+y*bpl+x));
  1256. */
  1257.   drawrp.BitMap=bm;
  1258.   SetAPen(&drawrp,X11DrawablesBackground[drawable]);
  1259.   RectFill(&drawrp,0,0,width-1,height-1);
  1260.   prevgc=(GC)-1;
  1261.   SetDrMd(&drawrp,JAM1);
  1262.   SetAPen(&drawrp,0);
  1263.  
  1264.   BltTemplate(bitmap->Planes[0],0,bitmap->BytesPerRow,&drawrp,0,0,width,height);
  1265.   SetAPen(&drawrp,1);
  1266.   WaitBlit();
  1267.   BltPattern(&drawrp,bitmap->Planes[0],0,0,width,height,bm->BytesPerRow);
  1268.   XFreePixmap(NULL,pm2);
  1269. /*
  1270.   free_bitmap(bitmap);
  1271. */
  1272. #else
  1273.   if(depth==8){
  1274.     pm=XCreatePixmap(display,drawable,width,height,depth);
  1275.     memcpy(((struct BitMap*)pm)->Planes[0],data,((struct BitMap*)pm)->BytesPerRow*((struct BitMap*)pm)->Rows);
  1276.   }
  1277.   else
  1278.     return(XCreateBitmapFromData(display,drawable,data,width,height));
  1279. #endif
  1280.   return(pm);
  1281. }
  1282.  
  1283. XFreePixmap(display, pixmap)
  1284.      Display *display;
  1285.      Pixmap pixmap;
  1286. {
  1287.   struct BitMap *bitmap=X11DrawablesBitmaps[X11DrawablesMap[pixmap]].pBitMap;
  1288. #ifdef DEBUGXEMUL_ENTRY
  1289.   printf("XFreePixmap\n");
  1290. #endif
  1291.   if(X11DrawablesBitmaps[X11DrawablesMap[pixmap]].bTileStipple) return;
  1292.  
  1293.   free_bitmap(bitmap);
  1294.   X11DrawablesBitmaps[X11DrawablesMap[pixmap]].pBitMap=NULL;
  1295.   return(0);
  1296. }
  1297.  
  1298. int XPixmapDepth(Display *display,Pixmap pixmap){
  1299.   struct BitMap *bm;
  1300.   if(X11Drawables[pixmap]!=X11BITMAP) return 0;
  1301.   bm=X11DrawablesBitmaps[X11DrawablesMap[pixmap]].pBitMap;
  1302.   return(bm->Depth);
  1303. }
  1304.  
  1305. Pixmap XCreatePixmap(display, drawable, width, height, depth)
  1306.      Display *display;
  1307.      Drawable drawable;
  1308.      unsigned int width, height;
  1309.      unsigned int depth;
  1310. {
  1311.   struct BitMap * bitmap;
  1312. #ifdef DEBUGXEMUL_ENTRY
  1313.   printf("XCreatePixmap (w %d,h %d,d %d)\n",width,height,depth);
  1314. #endif
  1315.   bitmap=alloc_bitmap(width,height,depth,BMF_CLEAR);
  1316.   if(!bitmap) X11resource_exit(IMAGES12);
  1317.   return((Pixmap)X11NewBitmap(bitmap,width,height,depth));
  1318. }
  1319.  
  1320. int XReadBitmapFile(display, d, filename, width_return,
  1321.             height_return, bitmap_return, x_hot_return, y_hot_return)
  1322.      Display *display;
  1323.      Drawable d;
  1324.      char *filename;
  1325.      unsigned int *width_return, *height_return;
  1326.      Pixmap *bitmap_return;
  1327.      int *x_hot_return, *y_hot_return;
  1328. {
  1329.   char line[256],line2[256];
  1330.   FILE *fp;
  1331.   struct BitMap *bm;
  1332.   int v,i,bytes,c,/*swap=0,*/perline,base;
  1333. #ifdef DEBUGXEMUL_ENTRY
  1334.   printf("XReadBitmapFile [%s]\n",filename);
  1335. #endif
  1336.   fp=fopen(filename,"r+");
  1337.   if(!fp) return(1);
  1338.   fgets(line,256,fp); sscanf(line,"%s %s %d",line2,line2,width_return);
  1339.   fgets(line,256,fp); sscanf(line,"%s %s %d",line2,line2,height_return);
  1340.   fgets(line,256,fp);
  1341.   if(line[0]=='#'){
  1342.     sscanf(line,"%s %s %d",line2,line2,x_hot_return);
  1343.     fgets(line,256,fp);
  1344.     sscanf(line,"%s %s %d",line2,line2,y_hot_return);
  1345.     fgets(line,256,fp);
  1346.   }
  1347.   *bitmap_return=XCreatePixmap(display,d,*width_return,*height_return,1);
  1348.   perline=((*width_return)+7)>>3;
  1349.   bytes=perline*(*height_return);
  1350. /*  if(*width_return>8) swap=1;*/
  1351.   if(perline&1) base=perline+1;
  1352.   else base=perline;
  1353.   bm=X11DrawablesBitmaps[X11DrawablesMap[*bitmap_return]].pBitMap;
  1354.   
  1355.   for(i=0;i<bytes;i++){
  1356.     UBYTE *b=bm->Planes[0];
  1357.     fscanf(fp,"%x%c",&v,&c);
  1358.     *(b+(int)(i/perline)*base+i%perline)=X11invert((UBYTE)v);
  1359.   }
  1360.   *width_return=(((*width_return)+7)>>3)<<3;
  1361.   fclose(fp);
  1362.   return(0);
  1363. }
  1364.  
  1365. int XWriteBitmapFile(display, filename, bitmap, width,
  1366.              height, x_hot, y_hot)
  1367.      Display *display;
  1368.      char *filename;
  1369.      Pixmap bitmap;
  1370.      unsigned int width, height;
  1371.      int x_hot, y_hot;
  1372. {/*        File 'f_wrxbm.o'*/
  1373.   char outname[40];
  1374.   FILE *fptr;
  1375.   int i,j,k=0;
  1376.   struct BitMap *bm=X11DrawablesBitmaps[X11DrawablesMap[bitmap]].pBitMap;
  1377.   unsigned char *outdata=bm->Planes[0];
  1378. #ifdef DEBUGXEMUL_ENTRY
  1379.   printf("XWriteBitmapFile\n");
  1380. #endif
  1381.   if(strchr(filename,'/')!=NULL)
  1382.     strcpy(outname,strrchr(filename,'/')+1);
  1383.   else
  1384.     if(strchr(filename,':')!=NULL)
  1385.       strcpy(outname,strrchr(filename,':')+1);
  1386.     else
  1387.       strcpy(outname,filename);
  1388.   if(strchr(outname,'.')!=NULL) *strchr(outname,'.')=0;
  1389.   fptr=fopen(filename,"w+");
  1390.   if(!fptr) return(BitmapOpenFailed);
  1391.   fprintf(fptr,"#define %s_width %d\n",outname,width);
  1392.   fprintf(fptr,"#define %s_height %d\n",outname,height);
  1393.   fprintf(fptr,"#define %s_x_hot %d\n",outname,x_hot);
  1394.   fprintf(fptr,"#define %s_y_hot %d\n",outname,y_hot);
  1395.   fprintf(fptr,"static char %s_bits[] = {\n",outname);
  1396.   for(i=0;i<height;i++){
  1397.     for(j=0;j<(width+7)>>3;j++){
  1398.       unsigned char c=X11invert((UBYTE)(*(outdata+i*bm->BytesPerRow+j)));
  1399.       fprintf(fptr,"0x%02x, ",c);
  1400.       k++;
  1401.       if(k==12){ fprintf(fptr,"\n"); k=0;}
  1402.     }
  1403.   }
  1404.   fprintf(fptr,"};");
  1405.   fclose(fptr);
  1406.   return(BitmapSuccess);
  1407. }
  1408.  
  1409. #ifdef DEBUG
  1410. void showbitmap(struct BitMap *bm,int width,int height,int pos){
  1411.   SetAPen(&(wb->RastPort),1);
  1412.   SetDrMd(&(wb->RastPort),JAM1);
  1413.   RectFill(&(wb->RastPort),20,22+200*pos,40+width,40+200*pos+height);
  1414.   BltBitMapRastPort(bm,0,0,&(wb->RastPort),22,30+200*pos,width,height,0xC0);
  1415. }
  1416.  
  1417. #endif
  1418. _XInitImageFuncPtrs(){/*     File 'image_f_io.o'*/
  1419. #if (DEBUGXEMUL_ENTRY) || (DEBUGXEMUL_WARNING)
  1420.   printf("WARNING:_XInitImageFuncPtrs\n");
  1421. #endif
  1422.   return(0);
  1423. }
  1424.